//auto gen by paipai.java.augogen ver 3.0.0
//author skyzhuang
//source idl: com.erp.storage.ao.idl.AddStockCheckReq.java


#ifndef ERP_STORAGE_PO_CSTOCKCHECKMASTERPO_BY_AUTOGEN_V5_H
#define ERP_STORAGE_PO_CSTOCKCHECKMASTERPO_BY_AUTOGEN_V5_H


#include "app_platform/intf_serializable.h"
#include <vector>
#include <bitset>
#include "erp/storage/po/stockcheckitempo_storage.h"
#include <string>
#include <sstream>
#include <iostream>


namespace erp
{
namespace storage
{
namespace po
{


class CStockCheckMasterPo : public ISerializable
{
	public:
		std::string m_sLastErrMsg;///<错误信息

		/**
		 *  版本号   
		 *
		 * 版本 >= 0
		 */
		uint32_t dwVersion;

		/**
		 * cVersion_u uflag field
		 */
		uint8_t cVersion_u; //optional flag

		/**
		 * 库存盘点SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwStockCheckMasterSysNo;

		/**
		 * cStockCheckMasterSysNo_u uflag field
		 */
		uint8_t cStockCheckMasterSysNo_u; //optional flag

		/**
		 * 业务单据号
		 *
		 * 版本 >= 0
		 */
		std::string strBillCode;

		/**
		 * cBillCode_u uflag field
		 */
		uint8_t cBillCode_u; //optional flag

		/**
		 * 仓库SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwStockSysNo;

		/**
		 * cStockSysNo_u uflag field
		 */
		uint8_t cStockSysNo_u; //optional flag

		/**
		 * 职员SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwStaffSysNo;

		/**
		 * cStaffSysNo_u uflag field
		 */
		uint8_t cStaffSysNo_u; //optional flag

		/**
		 * 往来单位SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwBusinessUnitsSysNo;

		/**
		 * cBusinessUnitsSysNo_u uflag field
		 */
		uint8_t cBusinessUnitsSysNo_u; //optional flag

		/**
		 * 部门SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwDepartmentSysNo;

		/**
		 * cDepartmentSysNo_u uflag field
		 */
		uint8_t cDepartmentSysNo_u; //optional flag

		/**
		 * 盘点状态
		 *
		 * 版本 >= 0
		 */
		uint16_t wCheckStatus;

		/**
		 * cCheckStatus_u uflag field
		 */
		uint8_t cCheckStatus_u; //optional flag

		/**
		 * 单据时间
		 *
		 * 版本 >= 0
		 */
		uint32_t dwBillDate;

		/**
		 * cBillDate_u uflag field
		 */
		uint8_t cBillDate_u; //optional flag

		/**
		 * 备注
		 *
		 * 版本 >= 0
		 */
		std::string strComment;

		/**
		 * cComment_u uflag field
		 */
		uint8_t cComment_u; //optional flag

		/**
		 * 盘点处理时间
		 *
		 * 版本 >= 0
		 */
		uint32_t dwAuditTime;

		/**
		 * cAuditTime_u uflag field
		 */
		uint8_t cAuditTime_u; //optional flag

		/**
		 * 盘点单明细项
		 *
		 * 版本 >= 0
		 */
		std::vector<erp::storage::po::CStockCheckItemPo>  vecVecStockCheckItemList;

		/**
		 * cVecStockCheckItemList_u uflag field
		 */
		uint8_t cVecStockCheckItemList_u; //optional flag

		/**
		 * 创建时间
		 *
		 * 版本 >= 0
		 */
		uint32_t dwRowCreatDate;

		/**
		 * cRowCreatDate_u uflag field
		 */
		uint8_t cRowCreatDate_u; //optional flag

		/**
		 * 创建人SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwCreatorSysNo;

		/**
		 * cCreatorSysNo_u uflag field
		 */
		uint8_t cCreatorSysNo_u; //optional flag

		/**
		 * 修改人SysNo
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwModifyUserSysNo;

		/**
		 * cModifyUserSysNo_u uflag field
		 */
		uint8_t cModifyUserSysNo_u; //optional flag

		/**
		 * 修改时间
		 *
		 * 版本 >= 0
		 */
		uint32_t dwModifyTime;

		/**
		 * cModifyTime_u uflag field
		 */
		uint8_t cModifyTime_u; //optional flag

		/**
		 * 盘点单属性,只读
		 *
		 * 版本 >= 0
		 */
		std::bitset<32>  bitsetStockCheckMasteProperty;

		/**
		 * cStockCheckMasteProperty_u uflag field
		 */
		uint8_t cStockCheckMasteProperty_u; //optional flag

		/**
		 * 盘点单属性,设置
		 *
		 * 版本 >= 0
		 */
		std::bitset<32>  bitsetStockCheckMastePropertyInclude;

		/**
		 * cStockCheckMastePropertyInclude_u uflag field
		 */
		uint8_t cStockCheckMastePropertyInclude_u; //optional flag

		/**
		 * 盘点单属性,取消
		 *
		 * 版本 >= 0
		 */
		std::bitset<32>  bitsetStockCheckMastePropertyExclude;

		/**
		 * cStockCheckMastePropertyExclude_u uflag field
		 */
		uint8_t cStockCheckMastePropertyExclude_u; //optional flag




	public:
		CStockCheckMasterPo():
		dwVersion(0),
		cVersion_u(0),
		ddwStockCheckMasterSysNo(0),
		cStockCheckMasterSysNo_u(0),
		cBillCode_u(0),
		ddwStockSysNo(0),
		cStockSysNo_u(0),
		ddwStaffSysNo(0),
		cStaffSysNo_u(0),
		ddwBusinessUnitsSysNo(0),
		cBusinessUnitsSysNo_u(0),
		ddwDepartmentSysNo(0),
		cDepartmentSysNo_u(0),
		wCheckStatus(0),
		cCheckStatus_u(0),
		dwBillDate(0),
		cBillDate_u(0),
		cComment_u(0),
		dwAuditTime(0),
		cAuditTime_u(0),
		cVecStockCheckItemList_u(0),
		dwRowCreatDate(0),
		cRowCreatDate_u(0),
		ddwCreatorSysNo(0),
		cCreatorSysNo_u(0),
		ddwModifyUserSysNo(0),
		cModifyUserSysNo_u(0),
		dwModifyTime(0),
		cModifyTime_u(0),
		cStockCheckMasteProperty_u(0),
		cStockCheckMastePropertyInclude_u(0),
		cStockCheckMastePropertyExclude_u(0) {}
				CStockCheckMasterPo& operator = (const CStockCheckMasterPo& obj){

			this->dwVersion = obj.dwVersion;
			this->ddwStockCheckMasterSysNo = obj.ddwStockCheckMasterSysNo;
			this->strBillCode = obj.strBillCode;
			this->ddwStockSysNo = obj.ddwStockSysNo;
			this->ddwStaffSysNo = obj.ddwStaffSysNo;
			this->ddwBusinessUnitsSysNo = obj.ddwBusinessUnitsSysNo;
			this->ddwDepartmentSysNo = obj.ddwDepartmentSysNo;
			this->wCheckStatus = obj.wCheckStatus;
			this->dwBillDate = obj.dwBillDate;
			this->strComment = obj.strComment;
			this->dwAuditTime = obj.dwAuditTime;
			this->vecVecStockCheckItemList = obj.vecVecStockCheckItemList;
			this->dwRowCreatDate = obj.dwRowCreatDate;
			this->ddwCreatorSysNo = obj.ddwCreatorSysNo;
			this->ddwModifyUserSysNo = obj.ddwModifyUserSysNo;
			this->dwModifyTime = obj.dwModifyTime;
			this->bitsetStockCheckMasteProperty = obj.bitsetStockCheckMasteProperty;
			this->bitsetStockCheckMastePropertyInclude = obj.bitsetStockCheckMastePropertyInclude;
			this->bitsetStockCheckMastePropertyExclude = obj.bitsetStockCheckMastePropertyExclude;
			this->cVersion_u = obj.cVersion_u;
			this->cStockCheckMasterSysNo_u = obj.cStockCheckMasterSysNo_u;
			this->cBillCode_u = obj.cBillCode_u;
			this->cStockSysNo_u = obj.cStockSysNo_u;
			this->cStaffSysNo_u = obj.cStaffSysNo_u;
			this->cBusinessUnitsSysNo_u = obj.cBusinessUnitsSysNo_u;
			this->cDepartmentSysNo_u = obj.cDepartmentSysNo_u;
			this->cCheckStatus_u = obj.cCheckStatus_u;
			this->cBillDate_u = obj.cBillDate_u;
			this->cComment_u = obj.cComment_u;
			this->cAuditTime_u = obj.cAuditTime_u;
			this->cVecStockCheckItemList_u = obj.cVecStockCheckItemList_u;
			this->cRowCreatDate_u = obj.cRowCreatDate_u;
			this->cCreatorSysNo_u = obj.cCreatorSysNo_u;
			this->cModifyUserSysNo_u = obj.cModifyUserSysNo_u;
			this->cModifyTime_u = obj.cModifyTime_u;
			this->cStockCheckMasteProperty_u = obj.cStockCheckMasteProperty_u;
			this->cStockCheckMastePropertyInclude_u = obj.cStockCheckMastePropertyInclude_u;
			this->cStockCheckMastePropertyExclude_u = obj.cStockCheckMastePropertyExclude_u;
			return *this;
		}

	public:


		/**
		 * 是否设置 版本号   了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 bool  IsVersionSet() const{
				 return  cVersion_u != 0;
		}


		/**
		 * 获取uflag 版本号   了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 const uint8_t   GetVersionUFlag() const{
				 return  cVersion_u;
		}


		/**
		 * 设置 版本号   
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 void  SetVersion( const uint32_t& sVal, uint8_t cUFlag=1){
				dwVersion = sVal;
				cVersion_u = cUFlag;
		}


		/**
		 * 获取 版本号   
		 * 
		 * @return dwVersion value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetVersion() const {
				return dwVersion;
		}


		/**
		 * 是否设置库存盘点SysNo了
		 * 
		 * @param uint64_t:ddwStockCheckMasterSysNo
		 *  
		 * 
		 */
		 bool  IsStockCheckMasterSysNoSet() const{
				 return  cStockCheckMasterSysNo_u != 0;
		}


		/**
		 * 获取uflag库存盘点SysNo了
		 * 
		 * @param uint64_t:ddwStockCheckMasterSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetStockCheckMasterSysNoUFlag() const{
				 return  cStockCheckMasterSysNo_u;
		}


		/**
		 * 设置库存盘点SysNo
		 * 
		 * @param uint64_t:ddwStockCheckMasterSysNo
		 *  
		 * 
		 */
		 void  SetStockCheckMasterSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwStockCheckMasterSysNo = sVal;
				cStockCheckMasterSysNo_u = cUFlag;
		}


		/**
		 * 获取库存盘点SysNo
		 * 
		 * @return ddwStockCheckMasterSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetStockCheckMasterSysNo() const {
				return ddwStockCheckMasterSysNo;
		}


		/**
		 * 是否设置业务单据号了
		 * 
		 * @param std::string:strBillCode
		 *  
		 * 
		 */
		 bool  IsBillCodeSet() const{
				 return  cBillCode_u != 0;
		}


		/**
		 * 获取uflag业务单据号了
		 * 
		 * @param std::string:strBillCode
		 *  
		 * 
		 */
		 const uint8_t   GetBillCodeUFlag() const{
				 return  cBillCode_u;
		}


		/**
		 * 设置业务单据号
		 * 
		 * @param std::string:strBillCode
		 *  
		 * 
		 */
		 void  SetBillCode( const std::string& sVal, uint8_t cUFlag=1){
				strBillCode = sVal;
				cBillCode_u = cUFlag;
		}


		/**
		 * 获取业务单据号
		 * 
		 * @return strBillCode value 类型为:std::string
		 * 
		 */
		 const std::string&  GetBillCode() const {
				return strBillCode;
		}


		/**
		 * 获取业务单据号
		 * 
		 * @return strBillCode value 类型为:std::string
		 * 
		 */
		 std::string&  GetBillCode() {
				return strBillCode;
		}


		/**
		 * 是否设置仓库SysNo了
		 * 
		 * @param uint64_t:ddwStockSysNo
		 *  
		 * 
		 */
		 bool  IsStockSysNoSet() const{
				 return  cStockSysNo_u != 0;
		}


		/**
		 * 获取uflag仓库SysNo了
		 * 
		 * @param uint64_t:ddwStockSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetStockSysNoUFlag() const{
				 return  cStockSysNo_u;
		}


		/**
		 * 设置仓库SysNo
		 * 
		 * @param uint64_t:ddwStockSysNo
		 *  
		 * 
		 */
		 void  SetStockSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwStockSysNo = sVal;
				cStockSysNo_u = cUFlag;
		}


		/**
		 * 获取仓库SysNo
		 * 
		 * @return ddwStockSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetStockSysNo() const {
				return ddwStockSysNo;
		}


		/**
		 * 是否设置职员SysNo了
		 * 
		 * @param uint64_t:ddwStaffSysNo
		 *  
		 * 
		 */
		 bool  IsStaffSysNoSet() const{
				 return  cStaffSysNo_u != 0;
		}


		/**
		 * 获取uflag职员SysNo了
		 * 
		 * @param uint64_t:ddwStaffSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetStaffSysNoUFlag() const{
				 return  cStaffSysNo_u;
		}


		/**
		 * 设置职员SysNo
		 * 
		 * @param uint64_t:ddwStaffSysNo
		 *  
		 * 
		 */
		 void  SetStaffSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwStaffSysNo = sVal;
				cStaffSysNo_u = cUFlag;
		}


		/**
		 * 获取职员SysNo
		 * 
		 * @return ddwStaffSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetStaffSysNo() const {
				return ddwStaffSysNo;
		}


		/**
		 * 是否设置往来单位SysNo了
		 * 
		 * @param uint64_t:ddwBusinessUnitsSysNo
		 *  
		 * 
		 */
		 bool  IsBusinessUnitsSysNoSet() const{
				 return  cBusinessUnitsSysNo_u != 0;
		}


		/**
		 * 获取uflag往来单位SysNo了
		 * 
		 * @param uint64_t:ddwBusinessUnitsSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetBusinessUnitsSysNoUFlag() const{
				 return  cBusinessUnitsSysNo_u;
		}


		/**
		 * 设置往来单位SysNo
		 * 
		 * @param uint64_t:ddwBusinessUnitsSysNo
		 *  
		 * 
		 */
		 void  SetBusinessUnitsSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwBusinessUnitsSysNo = sVal;
				cBusinessUnitsSysNo_u = cUFlag;
		}


		/**
		 * 获取往来单位SysNo
		 * 
		 * @return ddwBusinessUnitsSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetBusinessUnitsSysNo() const {
				return ddwBusinessUnitsSysNo;
		}


		/**
		 * 是否设置部门SysNo了
		 * 
		 * @param uint64_t:ddwDepartmentSysNo
		 *  
		 * 
		 */
		 bool  IsDepartmentSysNoSet() const{
				 return  cDepartmentSysNo_u != 0;
		}


		/**
		 * 获取uflag部门SysNo了
		 * 
		 * @param uint64_t:ddwDepartmentSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetDepartmentSysNoUFlag() const{
				 return  cDepartmentSysNo_u;
		}


		/**
		 * 设置部门SysNo
		 * 
		 * @param uint64_t:ddwDepartmentSysNo
		 *  
		 * 
		 */
		 void  SetDepartmentSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwDepartmentSysNo = sVal;
				cDepartmentSysNo_u = cUFlag;
		}


		/**
		 * 获取部门SysNo
		 * 
		 * @return ddwDepartmentSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetDepartmentSysNo() const {
				return ddwDepartmentSysNo;
		}


		/**
		 * 是否设置盘点状态了
		 * 
		 * @param uint16_t:wCheckStatus
		 *  
		 * 
		 */
		 bool  IsCheckStatusSet() const{
				 return  cCheckStatus_u != 0;
		}


		/**
		 * 获取uflag盘点状态了
		 * 
		 * @param uint16_t:wCheckStatus
		 *  
		 * 
		 */
		 const uint8_t   GetCheckStatusUFlag() const{
				 return  cCheckStatus_u;
		}


		/**
		 * 设置盘点状态
		 * 
		 * @param uint16_t:wCheckStatus
		 *  
		 * 
		 */
		 void  SetCheckStatus( const uint16_t& sVal, uint8_t cUFlag=1){
				wCheckStatus = sVal;
				cCheckStatus_u = cUFlag;
		}


		/**
		 * 获取盘点状态
		 * 
		 * @return wCheckStatus value 类型为:uint16_t
		 * 
		 */
		 const uint16_t&  GetCheckStatus() const {
				return wCheckStatus;
		}


		/**
		 * 是否设置单据时间了
		 * 
		 * @param uint32_t:dwBillDate
		 *  
		 * 
		 */
		 bool  IsBillDateSet() const{
				 return  cBillDate_u != 0;
		}


		/**
		 * 获取uflag单据时间了
		 * 
		 * @param uint32_t:dwBillDate
		 *  
		 * 
		 */
		 const uint8_t   GetBillDateUFlag() const{
				 return  cBillDate_u;
		}


		/**
		 * 设置单据时间
		 * 
		 * @param uint32_t:dwBillDate
		 *  
		 * 
		 */
		 void  SetBillDate( const uint32_t& sVal, uint8_t cUFlag=1){
				dwBillDate = sVal;
				cBillDate_u = cUFlag;
		}


		/**
		 * 获取单据时间
		 * 
		 * @return dwBillDate value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetBillDate() const {
				return dwBillDate;
		}


		/**
		 * 是否设置备注了
		 * 
		 * @param std::string:strComment
		 *  
		 * 
		 */
		 bool  IsCommentSet() const{
				 return  cComment_u != 0;
		}


		/**
		 * 获取uflag备注了
		 * 
		 * @param std::string:strComment
		 *  
		 * 
		 */
		 const uint8_t   GetCommentUFlag() const{
				 return  cComment_u;
		}


		/**
		 * 设置备注
		 * 
		 * @param std::string:strComment
		 *  
		 * 
		 */
		 void  SetComment( const std::string& sVal, uint8_t cUFlag=1){
				strComment = sVal;
				cComment_u = cUFlag;
		}


		/**
		 * 获取备注
		 * 
		 * @return strComment value 类型为:std::string
		 * 
		 */
		 const std::string&  GetComment() const {
				return strComment;
		}


		/**
		 * 获取备注
		 * 
		 * @return strComment value 类型为:std::string
		 * 
		 */
		 std::string&  GetComment() {
				return strComment;
		}


		/**
		 * 是否设置盘点处理时间了
		 * 
		 * @param uint32_t:dwAuditTime
		 *  
		 * 
		 */
		 bool  IsAuditTimeSet() const{
				 return  cAuditTime_u != 0;
		}


		/**
		 * 获取uflag盘点处理时间了
		 * 
		 * @param uint32_t:dwAuditTime
		 *  
		 * 
		 */
		 const uint8_t   GetAuditTimeUFlag() const{
				 return  cAuditTime_u;
		}


		/**
		 * 设置盘点处理时间
		 * 
		 * @param uint32_t:dwAuditTime
		 *  
		 * 
		 */
		 void  SetAuditTime( const uint32_t& sVal, uint8_t cUFlag=1){
				dwAuditTime = sVal;
				cAuditTime_u = cUFlag;
		}


		/**
		 * 获取盘点处理时间
		 * 
		 * @return dwAuditTime value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetAuditTime() const {
				return dwAuditTime;
		}


		/**
		 * 是否设置盘点单明细项了
		 * 
		 * @param std::vector<erp::storage::po::CStockCheckItemPo> :vecVecStockCheckItemList
		 *  
		 * 
		 */
		 bool  IsVecStockCheckItemListSet() const{
				 return  cVecStockCheckItemList_u != 0;
		}


		/**
		 * 获取uflag盘点单明细项了
		 * 
		 * @param std::vector<erp::storage::po::CStockCheckItemPo> :vecVecStockCheckItemList
		 *  
		 * 
		 */
		 const uint8_t   GetVecStockCheckItemListUFlag() const{
				 return  cVecStockCheckItemList_u;
		}


		/**
		 * 设置盘点单明细项
		 * 
		 * @param std::vector<erp::storage::po::CStockCheckItemPo> :vecVecStockCheckItemList
		 *  
		 * 
		 */
		 void  SetVecStockCheckItemList( const std::vector<erp::storage::po::CStockCheckItemPo> & sVal, uint8_t cUFlag=1){
				vecVecStockCheckItemList = sVal;
				cVecStockCheckItemList_u = cUFlag;
		}


		/**
		 * 获取盘点单明细项
		 * 
		 * @return vecVecStockCheckItemList value 类型为:std::vector<erp::storage::po::CStockCheckItemPo> 
		 * 
		 */
		 const std::vector<erp::storage::po::CStockCheckItemPo> &  GetVecStockCheckItemList() const {
				return vecVecStockCheckItemList;
		}


		/**
		 * 获取盘点单明细项
		 * 
		 * @return vecVecStockCheckItemList value 类型为:std::vector<erp::storage::po::CStockCheckItemPo> 
		 * 
		 */
		 std::vector<erp::storage::po::CStockCheckItemPo> &  GetVecStockCheckItemList() {
				return vecVecStockCheckItemList;
		}


		/**
		 * 是否设置创建时间了
		 * 
		 * @param uint32_t:dwRowCreatDate
		 *  
		 * 
		 */
		 bool  IsRowCreatDateSet() const{
				 return  cRowCreatDate_u != 0;
		}


		/**
		 * 获取uflag创建时间了
		 * 
		 * @param uint32_t:dwRowCreatDate
		 *  
		 * 
		 */
		 const uint8_t   GetRowCreatDateUFlag() const{
				 return  cRowCreatDate_u;
		}


		/**
		 * 设置创建时间
		 * 
		 * @param uint32_t:dwRowCreatDate
		 *  
		 * 
		 */
		 void  SetRowCreatDate( const uint32_t& sVal, uint8_t cUFlag=1){
				dwRowCreatDate = sVal;
				cRowCreatDate_u = cUFlag;
		}


		/**
		 * 获取创建时间
		 * 
		 * @return dwRowCreatDate value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetRowCreatDate() const {
				return dwRowCreatDate;
		}


		/**
		 * 是否设置创建人SysNo了
		 * 
		 * @param uint64_t:ddwCreatorSysNo
		 *  
		 * 
		 */
		 bool  IsCreatorSysNoSet() const{
				 return  cCreatorSysNo_u != 0;
		}


		/**
		 * 获取uflag创建人SysNo了
		 * 
		 * @param uint64_t:ddwCreatorSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetCreatorSysNoUFlag() const{
				 return  cCreatorSysNo_u;
		}


		/**
		 * 设置创建人SysNo
		 * 
		 * @param uint64_t:ddwCreatorSysNo
		 *  
		 * 
		 */
		 void  SetCreatorSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwCreatorSysNo = sVal;
				cCreatorSysNo_u = cUFlag;
		}


		/**
		 * 获取创建人SysNo
		 * 
		 * @return ddwCreatorSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetCreatorSysNo() const {
				return ddwCreatorSysNo;
		}


		/**
		 * 是否设置修改人SysNo了
		 * 
		 * @param uint64_t:ddwModifyUserSysNo
		 *  
		 * 
		 */
		 bool  IsModifyUserSysNoSet() const{
				 return  cModifyUserSysNo_u != 0;
		}


		/**
		 * 获取uflag修改人SysNo了
		 * 
		 * @param uint64_t:ddwModifyUserSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetModifyUserSysNoUFlag() const{
				 return  cModifyUserSysNo_u;
		}


		/**
		 * 设置修改人SysNo
		 * 
		 * @param uint64_t:ddwModifyUserSysNo
		 *  
		 * 
		 */
		 void  SetModifyUserSysNo( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwModifyUserSysNo = sVal;
				cModifyUserSysNo_u = cUFlag;
		}


		/**
		 * 获取修改人SysNo
		 * 
		 * @return ddwModifyUserSysNo value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetModifyUserSysNo() const {
				return ddwModifyUserSysNo;
		}


		/**
		 * 是否设置修改时间了
		 * 
		 * @param uint32_t:dwModifyTime
		 *  
		 * 
		 */
		 bool  IsModifyTimeSet() const{
				 return  cModifyTime_u != 0;
		}


		/**
		 * 获取uflag修改时间了
		 * 
		 * @param uint32_t:dwModifyTime
		 *  
		 * 
		 */
		 const uint8_t   GetModifyTimeUFlag() const{
				 return  cModifyTime_u;
		}


		/**
		 * 设置修改时间
		 * 
		 * @param uint32_t:dwModifyTime
		 *  
		 * 
		 */
		 void  SetModifyTime( const uint32_t& sVal, uint8_t cUFlag=1){
				dwModifyTime = sVal;
				cModifyTime_u = cUFlag;
		}


		/**
		 * 获取修改时间
		 * 
		 * @return dwModifyTime value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetModifyTime() const {
				return dwModifyTime;
		}


		/**
		 * 是否设置盘点单属性,只读了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckMasteProperty
		 *  
		 * 
		 */
		 bool  IsStockCheckMastePropertySet() const{
				 return  cStockCheckMasteProperty_u != 0;
		}


		/**
		 * 获取uflag盘点单属性,只读了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckMasteProperty
		 *  
		 * 
		 */
		 const uint8_t   GetStockCheckMastePropertyUFlag() const{
				 return  cStockCheckMasteProperty_u;
		}


		/**
		 * 设置盘点单属性,只读
		 * 
		 * @param std::bitset<32> :bitsetStockCheckMasteProperty
		 *  
		 * 
		 */
		 void  SetStockCheckMasteProperty( const std::bitset<32> & sVal, uint8_t cUFlag=1){
				bitsetStockCheckMasteProperty = sVal;
				cStockCheckMasteProperty_u = cUFlag;
		}


		/**
		 * 获取盘点单属性,只读
		 * 
		 * @return bitsetStockCheckMasteProperty value 类型为:std::bitset<32> 
		 * 
		 */
		 const std::bitset<32> &  GetStockCheckMasteProperty() const {
				return bitsetStockCheckMasteProperty;
		}


		/**
		 * 获取盘点单属性,只读
		 * 
		 * @return bitsetStockCheckMasteProperty value 类型为:std::bitset<32> 
		 * 
		 */
		 std::bitset<32> &  GetStockCheckMasteProperty() {
				return bitsetStockCheckMasteProperty;
		}


		/**
		 * 是否设置盘点单属性,设置了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckMastePropertyInclude
		 *  
		 * 
		 */
		 bool  IsStockCheckMastePropertyIncludeSet() const{
				 return  cStockCheckMastePropertyInclude_u != 0;
		}


		/**
		 * 获取uflag盘点单属性,设置了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckMastePropertyInclude
		 *  
		 * 
		 */
		 const uint8_t   GetStockCheckMastePropertyIncludeUFlag() const{
				 return  cStockCheckMastePropertyInclude_u;
		}


		/**
		 * 设置盘点单属性,设置
		 * 
		 * @param std::bitset<32> :bitsetStockCheckMastePropertyInclude
		 *  
		 * 
		 */
		 void  SetStockCheckMastePropertyInclude( const std::bitset<32> & sVal, uint8_t cUFlag=1){
				bitsetStockCheckMastePropertyInclude = sVal;
				cStockCheckMastePropertyInclude_u = cUFlag;
		}


		/**
		 * 获取盘点单属性,设置
		 * 
		 * @return bitsetStockCheckMastePropertyInclude value 类型为:std::bitset<32> 
		 * 
		 */
		 const std::bitset<32> &  GetStockCheckMastePropertyInclude() const {
				return bitsetStockCheckMastePropertyInclude;
		}


		/**
		 * 获取盘点单属性,设置
		 * 
		 * @return bitsetStockCheckMastePropertyInclude value 类型为:std::bitset<32> 
		 * 
		 */
		 std::bitset<32> &  GetStockCheckMastePropertyInclude() {
				return bitsetStockCheckMastePropertyInclude;
		}


		/**
		 * 是否设置盘点单属性,取消了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckMastePropertyExclude
		 *  
		 * 
		 */
		 bool  IsStockCheckMastePropertyExcludeSet() const{
				 return  cStockCheckMastePropertyExclude_u != 0;
		}


		/**
		 * 获取uflag盘点单属性,取消了
		 * 
		 * @param std::bitset<32> :bitsetStockCheckMastePropertyExclude
		 *  
		 * 
		 */
		 const uint8_t   GetStockCheckMastePropertyExcludeUFlag() const{
				 return  cStockCheckMastePropertyExclude_u;
		}


		/**
		 * 设置盘点单属性,取消
		 * 
		 * @param std::bitset<32> :bitsetStockCheckMastePropertyExclude
		 *  
		 * 
		 */
		 void  SetStockCheckMastePropertyExclude( const std::bitset<32> & sVal, uint8_t cUFlag=1){
				bitsetStockCheckMastePropertyExclude = sVal;
				cStockCheckMastePropertyExclude_u = cUFlag;
		}


		/**
		 * 获取盘点单属性,取消
		 * 
		 * @return bitsetStockCheckMastePropertyExclude value 类型为:std::bitset<32> 
		 * 
		 */
		 const std::bitset<32> &  GetStockCheckMastePropertyExclude() const {
				return bitsetStockCheckMastePropertyExclude;
		}


		/**
		 * 获取盘点单属性,取消
		 * 
		 * @return bitsetStockCheckMastePropertyExclude value 类型为:std::bitset<32> 
		 * 
		 */
		 std::bitset<32> &  GetStockCheckMastePropertyExclude() {
				return bitsetStockCheckMastePropertyExclude;
		}

		virtual bool Serialize(CByteStreamNetwork& bs){
		
			uint32_t dwMyLen = 0;
			if(bs.isStoring()) //for write in buffer
			{
				//can not larger than 1 M.
				CByteStreamNetwork bsDummy(NULL, 1024 * 1024, false);
				//bsDummy for precheck the xo size...
				bsDummy.isStoring(true);
				Serialize_i(bsDummy);
				dwMyLen = bsDummy.getWrittenLength();
				bs & dwMyLen;
				Serialize_i(bs);
			}
			else
			{    //for read from buffer
				bs & dwMyLen;
				uint32_t dwReadedLen = bs.getReadLength();
				Serialize_i(bs);
				dwReadedLen = bs.getReadLength() - dwReadedLen;
				// dwReadedLen for the size of xo
				if( dwReadedLen > dwMyLen ){
					return false;
				}
				//go through the unwanted mem position...
				bs.goForward( dwMyLen - dwReadedLen );
			}

			return bs.isGood();
		}

		bool Serialize_i(CByteStreamNetwork& bsTmp){

			bsTmp & dwVersion; // 序列化 版本号    类型为uint32_t
			bsTmp & cVersion_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwStockCheckMasterSysNo; // 序列化库存盘点SysNo 类型为uint64_t
			bsTmp & cStockCheckMasterSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & strBillCode; // 序列化业务单据号 类型为String
			bsTmp & cBillCode_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwStockSysNo; // 序列化仓库SysNo 类型为uint64_t
			bsTmp & cStockSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwStaffSysNo; // 序列化职员SysNo 类型为uint64_t
			bsTmp & cStaffSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwBusinessUnitsSysNo; // 序列化往来单位SysNo 类型为uint64_t
			bsTmp & cBusinessUnitsSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwDepartmentSysNo; // 序列化部门SysNo 类型为uint64_t
			bsTmp & cDepartmentSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & wCheckStatus; // 序列化盘点状态 类型为uint16_t
			bsTmp & cCheckStatus_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwBillDate; // 序列化单据时间 类型为uint32_t
			bsTmp & cBillDate_u; // 序列化uflag 类型为uint8_t
			bsTmp & strComment; // 序列化备注 类型为String
			bsTmp & cComment_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwAuditTime; // 序列化盘点处理时间 类型为uint32_t
			bsTmp & cAuditTime_u; // 序列化uflag 类型为uint8_t
			bsTmp & vecVecStockCheckItemList; // 序列化盘点单明细项 类型为Vector
			bsTmp & cVecStockCheckItemList_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwRowCreatDate; // 序列化创建时间 类型为uint32_t
			bsTmp & cRowCreatDate_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwCreatorSysNo; // 序列化创建人SysNo 类型为uint64_t
			bsTmp & cCreatorSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & ddwModifyUserSysNo; // 序列化修改人SysNo 类型为uint64_t
			bsTmp & cModifyUserSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwModifyTime; // 序列化修改时间 类型为uint32_t
			bsTmp & cModifyTime_u; // 序列化uflag 类型为uint8_t
			bsTmp & bitsetStockCheckMasteProperty; // 序列化盘点单属性,只读 类型为BitSet
			bsTmp & cStockCheckMasteProperty_u; // 序列化uflag 类型为uint8_t
			bsTmp & bitsetStockCheckMastePropertyInclude; // 序列化盘点单属性,设置 类型为BitSet
			bsTmp & cStockCheckMastePropertyInclude_u; // 序列化uflag 类型为uint8_t
			bsTmp & bitsetStockCheckMastePropertyExclude; // 序列化盘点单属性,取消 类型为BitSet
			bsTmp & cStockCheckMastePropertyExclude_u; // 序列化uflag 类型为uint8_t
			return bsTmp.isGood();
		}

		const char* GetLastErrMsg() const{
			return m_sLastErrMsg.c_str();
		}

		bool VerifyStockCheckMasterPo(){

			if(!IsVersionSet()){
				m_sLastErrMsg = "Miss Param:version";
				return false;
			}

			if(!IsStockCheckMasterSysNoSet()){
				m_sLastErrMsg = "Miss Param:stockCheckMasterSysNo";
				return false;
			}

			if(!IsBillCodeSet()){
				m_sLastErrMsg = "Miss Param:billCode";
				return false;
			}

			if(!IsStockSysNoSet()){
				m_sLastErrMsg = "Miss Param:stockSysNo";
				return false;
			}

			if(!IsStaffSysNoSet()){
				m_sLastErrMsg = "Miss Param:staffSysNo";
				return false;
			}

			if(!IsBusinessUnitsSysNoSet()){
				m_sLastErrMsg = "Miss Param:businessUnitsSysNo";
				return false;
			}

			if(!IsDepartmentSysNoSet()){
				m_sLastErrMsg = "Miss Param:departmentSysNo";
				return false;
			}

			if(!IsCheckStatusSet()){
				m_sLastErrMsg = "Miss Param:checkStatus";
				return false;
			}

			if(!IsBillDateSet()){
				m_sLastErrMsg = "Miss Param:billDate";
				return false;
			}

			if(!IsCommentSet()){
				m_sLastErrMsg = "Miss Param:comment";
				return false;
			}

			if(!IsAuditTimeSet()){
				m_sLastErrMsg = "Miss Param:auditTime";
				return false;
			}

			if(!IsVecStockCheckItemListSet()){
				m_sLastErrMsg = "Miss Param:vecStockCheckItemList";
				return false;
			}

			if(!IsRowCreatDateSet()){
				m_sLastErrMsg = "Miss Param:rowCreatDate";
				return false;
			}

			if(!IsCreatorSysNoSet()){
				m_sLastErrMsg = "Miss Param:creatorSysNo";
				return false;
			}

			if(!IsModifyUserSysNoSet()){
				m_sLastErrMsg = "Miss Param:modifyUserSysNo";
				return false;
			}

			if(!IsModifyTimeSet()){
				m_sLastErrMsg = "Miss Param:modifyTime";
				return false;
			}

			if(!IsStockCheckMastePropertySet()){
				m_sLastErrMsg = "Miss Param:stockCheckMasteProperty";
				return false;
			}

			if(!IsStockCheckMastePropertyIncludeSet()){
				m_sLastErrMsg = "Miss Param:stockCheckMastePropertyInclude";
				return false;
			}

			if(!IsStockCheckMastePropertyExcludeSet()){
				m_sLastErrMsg = "Miss Param:stockCheckMastePropertyExclude";
				return false;
			}
			return true;
		}

		void DumpData(std::ostream& oss) const{
		
			oss<<"[dwVersion:"<<dwVersion<<"] ";
			oss<<"[cVersion_u:"<<(int)cVersion_u<<"] ";
			oss<<"[ddwStockCheckMasterSysNo:"<<ddwStockCheckMasterSysNo<<"] ";
			oss<<"[cStockCheckMasterSysNo_u:"<<(int)cStockCheckMasterSysNo_u<<"] ";
			oss<<"[strBillCode:"<<strBillCode<<"] ";
			oss<<"[cBillCode_u:"<<(int)cBillCode_u<<"] ";
			oss<<"[ddwStockSysNo:"<<ddwStockSysNo<<"] ";
			oss<<"[cStockSysNo_u:"<<(int)cStockSysNo_u<<"] ";
			oss<<"[ddwStaffSysNo:"<<ddwStaffSysNo<<"] ";
			oss<<"[cStaffSysNo_u:"<<(int)cStaffSysNo_u<<"] ";
			oss<<"[ddwBusinessUnitsSysNo:"<<ddwBusinessUnitsSysNo<<"] ";
			oss<<"[cBusinessUnitsSysNo_u:"<<(int)cBusinessUnitsSysNo_u<<"] ";
			oss<<"[ddwDepartmentSysNo:"<<ddwDepartmentSysNo<<"] ";
			oss<<"[cDepartmentSysNo_u:"<<(int)cDepartmentSysNo_u<<"] ";
			oss<<"[wCheckStatus:"<<(int)wCheckStatus<<"] ";
			oss<<"[cCheckStatus_u:"<<(int)cCheckStatus_u<<"] ";
			oss<<"[dwBillDate:"<<dwBillDate<<"] ";
			oss<<"[cBillDate_u:"<<(int)cBillDate_u<<"] ";
			oss<<"[strComment:"<<strComment<<"] ";
			oss<<"[cComment_u:"<<(int)cComment_u<<"] ";
			oss<<"[dwAuditTime:"<<dwAuditTime<<"] ";
			oss<<"[cAuditTime_u:"<<(int)cAuditTime_u<<"] ";

			std::vector<erp::storage::po::CStockCheckItemPo>::const_iterator itervecVecStockCheckItemList=vecVecStockCheckItemList.begin();
			for(int i=0; itervecVecStockCheckItemList!=vecVecStockCheckItemList.end();itervecVecStockCheckItemList++,i++){
				oss<<"[vecVecStockCheckItemList:";
				itervecVecStockCheckItemList->DumpData(oss);
				oss<<"] ";
			}
			oss<<"[cVecStockCheckItemList_u:"<<(int)cVecStockCheckItemList_u<<"] ";
			oss<<"[dwRowCreatDate:"<<dwRowCreatDate<<"] ";
			oss<<"[cRowCreatDate_u:"<<(int)cRowCreatDate_u<<"] ";
			oss<<"[ddwCreatorSysNo:"<<ddwCreatorSysNo<<"] ";
			oss<<"[cCreatorSysNo_u:"<<(int)cCreatorSysNo_u<<"] ";
			oss<<"[ddwModifyUserSysNo:"<<ddwModifyUserSysNo<<"] ";
			oss<<"[cModifyUserSysNo_u:"<<(int)cModifyUserSysNo_u<<"] ";
			oss<<"[dwModifyTime:"<<dwModifyTime<<"] ";
			oss<<"[cModifyTime_u:"<<(int)cModifyTime_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cStockCheckMasteProperty_u:"<<(int)cStockCheckMasteProperty_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cStockCheckMastePropertyInclude_u:"<<(int)cStockCheckMastePropertyInclude_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cStockCheckMastePropertyExclude_u:"<<(int)cStockCheckMastePropertyExclude_u<<"] ";
		
		}

		// codydeng提供,非常好的dump方法 ^-^  。。。。。
		template<typename T>
		T & DumpPlusData(T& oss){
			oss<<"dwVersion:"<<dwVersion;
			oss<<"[cVersion_u:"<<cVersion_u<<"] ";
			oss<<"ddwStockCheckMasterSysNo:"<<ddwStockCheckMasterSysNo;
			oss<<"[cStockCheckMasterSysNo_u:"<<cStockCheckMasterSysNo_u<<"] ";
			oss<<"strBillCode:"<<strBillCode;
			oss<<"[cBillCode_u:"<<cBillCode_u<<"] ";
			oss<<"ddwStockSysNo:"<<ddwStockSysNo;
			oss<<"[cStockSysNo_u:"<<cStockSysNo_u<<"] ";
			oss<<"ddwStaffSysNo:"<<ddwStaffSysNo;
			oss<<"[cStaffSysNo_u:"<<cStaffSysNo_u<<"] ";
			oss<<"ddwBusinessUnitsSysNo:"<<ddwBusinessUnitsSysNo;
			oss<<"[cBusinessUnitsSysNo_u:"<<cBusinessUnitsSysNo_u<<"] ";
			oss<<"ddwDepartmentSysNo:"<<ddwDepartmentSysNo;
			oss<<"[cDepartmentSysNo_u:"<<cDepartmentSysNo_u<<"] ";
			oss<<"wCheckStatus:"<<wCheckStatus;
			oss<<"[cCheckStatus_u:"<<cCheckStatus_u<<"] ";
			oss<<"dwBillDate:"<<dwBillDate;
			oss<<"[cBillDate_u:"<<cBillDate_u<<"] ";
			oss<<"strComment:"<<strComment;
			oss<<"[cComment_u:"<<cComment_u<<"] ";
			oss<<"dwAuditTime:"<<dwAuditTime;
			oss<<"[cAuditTime_u:"<<cAuditTime_u<<"] ";
			oss<<"vecVecStockCheckItemList:"<<vecVecStockCheckItemList;
			oss<<"[cVecStockCheckItemList_u:"<<cVecStockCheckItemList_u<<"] ";
			oss<<"dwRowCreatDate:"<<dwRowCreatDate;
			oss<<"[cRowCreatDate_u:"<<cRowCreatDate_u<<"] ";
			oss<<"ddwCreatorSysNo:"<<ddwCreatorSysNo;
			oss<<"[cCreatorSysNo_u:"<<cCreatorSysNo_u<<"] ";
			oss<<"ddwModifyUserSysNo:"<<ddwModifyUserSysNo;
			oss<<"[cModifyUserSysNo_u:"<<cModifyUserSysNo_u<<"] ";
			oss<<"dwModifyTime:"<<dwModifyTime;
			oss<<"[cModifyTime_u:"<<cModifyTime_u<<"] ";
			oss<<"bitsetStockCheckMasteProperty:"<<bitsetStockCheckMasteProperty;
			oss<<"[cStockCheckMasteProperty_u:"<<cStockCheckMasteProperty_u<<"] ";
			oss<<"bitsetStockCheckMastePropertyInclude:"<<bitsetStockCheckMastePropertyInclude;
			oss<<"[cStockCheckMastePropertyInclude_u:"<<cStockCheckMastePropertyInclude_u<<"] ";
			oss<<"bitsetStockCheckMastePropertyExclude:"<<bitsetStockCheckMastePropertyExclude;
			oss<<"[cStockCheckMastePropertyExclude_u:"<<cStockCheckMastePropertyExclude_u<<"] ";
			return oss;
		}

		// wileywang提供,树形dump方法 ^-^  。。。。。
		void DumpDataTree(std::ostream& os, int ident = 0)const {
			g_pprint(os, "dwVersion", dwVersion, ident);
			g_pprint(os, "cVersion_u", cVersion_u, ident);
			g_pprint(os, "ddwStockCheckMasterSysNo", ddwStockCheckMasterSysNo, ident);
			g_pprint(os, "cStockCheckMasterSysNo_u", cStockCheckMasterSysNo_u, ident);
			g_pprint(os, "strBillCode", strBillCode, ident);
			g_pprint(os, "cBillCode_u", cBillCode_u, ident);
			g_pprint(os, "ddwStockSysNo", ddwStockSysNo, ident);
			g_pprint(os, "cStockSysNo_u", cStockSysNo_u, ident);
			g_pprint(os, "ddwStaffSysNo", ddwStaffSysNo, ident);
			g_pprint(os, "cStaffSysNo_u", cStaffSysNo_u, ident);
			g_pprint(os, "ddwBusinessUnitsSysNo", ddwBusinessUnitsSysNo, ident);
			g_pprint(os, "cBusinessUnitsSysNo_u", cBusinessUnitsSysNo_u, ident);
			g_pprint(os, "ddwDepartmentSysNo", ddwDepartmentSysNo, ident);
			g_pprint(os, "cDepartmentSysNo_u", cDepartmentSysNo_u, ident);
			g_pprint(os, "wCheckStatus", wCheckStatus, ident);
			g_pprint(os, "cCheckStatus_u", cCheckStatus_u, ident);
			g_pprint(os, "dwBillDate", dwBillDate, ident);
			g_pprint(os, "cBillDate_u", cBillDate_u, ident);
			g_pprint(os, "strComment", strComment, ident);
			g_pprint(os, "cComment_u", cComment_u, ident);
			g_pprint(os, "dwAuditTime", dwAuditTime, ident);
			g_pprint(os, "cAuditTime_u", cAuditTime_u, ident);
			g_pprint(os, "vecVecStockCheckItemList", vecVecStockCheckItemList, ident);
			g_pprint(os, "cVecStockCheckItemList_u", cVecStockCheckItemList_u, ident);
			g_pprint(os, "dwRowCreatDate", dwRowCreatDate, ident);
			g_pprint(os, "cRowCreatDate_u", cRowCreatDate_u, ident);
			g_pprint(os, "ddwCreatorSysNo", ddwCreatorSysNo, ident);
			g_pprint(os, "cCreatorSysNo_u", cCreatorSysNo_u, ident);
			g_pprint(os, "ddwModifyUserSysNo", ddwModifyUserSysNo, ident);
			g_pprint(os, "cModifyUserSysNo_u", cModifyUserSysNo_u, ident);
			g_pprint(os, "dwModifyTime", dwModifyTime, ident);
			g_pprint(os, "cModifyTime_u", cModifyTime_u, ident);
			g_pprint(os, "bitsetStockCheckMasteProperty", bitsetStockCheckMasteProperty, ident);
			g_pprint(os, "cStockCheckMasteProperty_u", cStockCheckMasteProperty_u, ident);
			g_pprint(os, "bitsetStockCheckMastePropertyInclude", bitsetStockCheckMastePropertyInclude, ident);
			g_pprint(os, "cStockCheckMastePropertyInclude_u", cStockCheckMastePropertyInclude_u, ident);
			g_pprint(os, "bitsetStockCheckMastePropertyExclude", bitsetStockCheckMastePropertyExclude, ident);
			g_pprint(os, "cStockCheckMastePropertyExclude_u", cStockCheckMastePropertyExclude_u, ident);
		}
		
		//提供ToString借口，默认为DumpData格式，请按需要进行修改
		std::string ToString() const{
			std::stringstream ss;
			DumpData(ss);
			return ss.str();
		}

/**
 ********************以下信息是每个版本的字段********************
 */

};

}
}
}

#endif /* ERP_STORAGE_PO_CSTOCKCHECKMASTERPO_BY_AUTOGEN_V5_H */
